'use strict';

// 云函数入口文件
const db = uniCloud.database();
const topicCollection = db.collection('topics');
const videoCollection = db.collection('videos');

/**
 * 专题相关云函数
 * 支持以下操作：
 * 1. 获取专题列表 - getTopicList
 * 2. 创建专题 - createTopic 
 * 3. 获取专题详情 - getTopicDetail
 * 4. 更新专题 - updateTopic
 * 5. 删除专题 - deleteTopic
 * 6. 获取专题的视频列表 - getTopicVideos
 */
exports.main = async (event, context) => {
	// 默认返回值
	let result = {
		code: -1,
		message: '未知操作',
		data: null
	};
	
	// 获取操作类型和用户信息
	const { action, userId, token } = event;
	
	// 对于需要强制登录的操作进行验证
	const requireLoginActions = ['createTopic', 'updateTopic', 'deleteTopic'];
	
	// 验证用户身份（对部分操作放宽要求）
	if (requireLoginActions.includes(action) && !userId) {
		return {
			code: -2,
			message: '用户未登录',
			data: null
		};
	}
	
	// 根据操作类型调用不同的处理函数
	try {
		switch (action) {
			case 'getTopicList':
				result = await getTopicList(event);
				break;
			case 'getMyTopics':
				result = await getMyTopics(event);
				break;
			case 'createTopic':
				result = await createTopic(event);
				break;
			case 'getTopicDetail':
				result = await getTopicDetail(event);
				break;
			case 'updateTopic':
				result = await updateTopic(event);
				break;
			case 'deleteTopic':
				result = await deleteTopic(event);
				break;
			case 'getTopicVideos':
				result = await getTopicVideos(event);
				break;
			default:
				result.message = `不支持的操作: ${action}`;
		}
	} catch (error) {
		console.error('专题操作异常:', error);
		result.code = -3;
		result.message = `操作出错: ${error.message}`;
	}
	
	return result;
};

/**
 * 获取专题列表
 */
async function getTopicList(event) {
	const { userId, page = 1, pageSize = 10 } = event;
	
	console.log('[getTopicList] 接收到的参数:', { userId, page, pageSize });
	
	try {
		// 首先测试数据库连接
		console.log('[getTopicList] 测试数据库连接...');
		const testResult = await topicCollection.count();
		console.log('[getTopicList] 数据库中专题总数:', testResult.total);
		
		let query = {};
		
		// 如果有用户ID，显示公开专题和用户自己的专题
		// 如果没有用户ID，只显示公开专题
		if (userId) {
			query = {
				$or: [
					{ isPublic: true },
					{ creator: userId }
				]
			};
		} else {
			// 未登录用户只能看到公开专题
			query = {
				isPublic: true
			};
		}
		
		console.log('[getTopicList] 查询条件:', JSON.stringify(query));
		
		// 先测试查询条件
		const testCountResult = await topicCollection.where(query).count();
		console.log('[getTopicList] 符合条件的专题数量:', testCountResult.total);
		
		// 分页获取数据
		const skip = (page - 1) * pageSize;
		const list = await topicCollection
			.where(query)
			.orderBy('createTime', 'desc')
			.skip(skip)
			.limit(pageSize)
			.get();
		
		console.log('[getTopicList] 查询结果数量:', list.data.length);
		if (list.data.length > 0) {
			console.log('[getTopicList] 第一条专题数据:', JSON.stringify(list.data[0]));
		}
		
		// 计算每个专题的视频数量
		for (let topic of list.data) {
			try {
				console.log(`[getTopicList] 正在计算专题 "${topic.title}" 的视频数量...`);
				const videoCount = await db.collection('learning_videos').where({
					topic_id: topic._id,
					video_type: 'topic',
					status: 'published' // 只计算已发布的视频
				}).count();
				topic.videoCount = videoCount.total;
				console.log(`[getTopicList] 专题 "${topic.title}" 视频数量: ${videoCount.total}`);
			} catch (error) {
				console.error(`[getTopicList] 获取专题 "${topic.title}" 视频数量失败:`, error);
				topic.videoCount = 0;
			}
		}
		
		console.log('[getTopicList] 计算视频数量完成，最终结果:', list.data.map(item => ({
			title: item.title,
			videoCount: item.videoCount
		})));
		
		// 获取总数
		const countResult = await topicCollection.where(query).count();
		
		return {
			code: 0,
			message: '获取专题列表成功',
			data: list.data,
			total: countResult.total
		};
	} catch (error) {
		console.error('获取专题列表失败:', error);
		return {
			code: -1,
			message: '获取专题列表失败: ' + error.message,
			data: null
		};
	}
}

/**
 * 获取用户创建的专题列表（用于管理）
 */
async function getMyTopics(event) {
	const { userId, page = 1, pageSize = 10 } = event;
	
	console.log('[getMyTopics] 接收到的参数:', { userId, page, pageSize });
	
	if (!userId) {
		return {
			code: -2,
			message: '用户未登录',
			data: null
		};
	}
	
	try {
		// 只获取用户自己创建的专题
		const query = {
			creator: userId
		};
		
		console.log('[getMyTopics] 查询条件:', JSON.stringify(query));
		
		// 分页获取数据
		const skip = (page - 1) * pageSize;
		const list = await topicCollection
			.where(query)
			.orderBy('createTime', 'desc')
			.skip(skip)
			.limit(pageSize)
			.get();
		
		console.log('[getMyTopics] 查询结果数量:', list.data.length);
		
		// 获取总数
		const countResult = await topicCollection.where(query).count();
		
		// 计算每个专题的视频数量
		for (let topic of list.data) {
			try {
				console.log(`[getMyTopics] 正在计算专题 "${topic.title}" 的视频数量...`);
				const videoCount = await db.collection('learning_videos').where({
					topic_id: topic._id,
					video_type: 'topic',
					status: 'published' // 只计算已发布的视频
				}).count();
				topic.videoCount = videoCount.total;
				console.log(`[getMyTopics] 专题 "${topic.title}" 视频数量: ${videoCount.total}`);
			} catch (error) {
				console.error(`[getMyTopics] 获取专题 "${topic.title}" 视频数量失败:`, error);
				topic.videoCount = 0;
			}
		}
		
		return {
			code: 0,
			message: '获取我的专题列表成功',
			data: list.data,
			total: countResult.total
		};
	} catch (error) {
		console.error('获取我的专题列表失败:', error);
		return {
			code: -1,
			message: '获取我的专题列表失败: ' + error.message,
			data: null
		};
	}
}

/**
 * 创建专题
 */
async function createTopic(event) {
	const { 
		userId, 
		title, 
		description, 
		cover_image, 
		allowOthersUpload = false,
		isPublic = true 
	} = event;
	
	if (!title || !description) {
		return {
			code: -1,
			message: '标题和描述不能为空',
			data: null
		};
	}
	
	try {
		// 创建专题数据
		const topicData = {
			title,
			description,
			cover_image,
			creator: userId,
			allowOthersUpload,
			isPublic,
			createTime: Date.now(),
			updateTime: Date.now(),
			videoCount: 0
		};
		
		// 添加到数据库
		const result = await topicCollection.add(topicData);
		
		return {
			code: 0,
			message: '创建专题成功',
			data: {
				id: result.id,
				...topicData
			}
		};
	} catch (error) {
		console.error('创建专题失败:', error);
		return {
			code: -1,
			message: '创建专题失败: ' + error.message,
			data: null
		};
	}
}

/**
 * 获取专题详情
 */
async function getTopicDetail(event) {
	const { topicId } = event;
	
	if (!topicId) {
		return {
			code: -1,
			message: '专题ID不能为空',
			data: null
		};
	}
	
	try {
		const result = await topicCollection.doc(topicId).get();
		
		if (!result.data || result.data.length === 0) {
			return {
				code: -1,
				message: '专题不存在',
				data: null
			};
		}
		
		return {
			code: 0,
			message: '获取专题详情成功',
			data: result.data[0]
		};
	} catch (error) {
		console.error('获取专题详情失败:', error);
		return {
			code: -1,
			message: '获取专题详情失败: ' + error.message,
			data: null
		};
	}
}

/**
 * 更新专题
 */
async function updateTopic(event) {
	const { 
		userId, 
		topicId, 
		title, 
		description, 
		cover_image,
		allowOthersUpload,
		isPublic
	} = event;
	
	if (!topicId) {
		return {
			code: -1,
			message: '专题ID不能为空',
			data: null
		};
	}
	
	try {
		// 检查是否是专题创建者
		const topicInfo = await topicCollection.doc(topicId).get();
		if (!topicInfo.data || topicInfo.data.length === 0) {
			return {
				code: -1,
				message: '专题不存在',
				data: null
			};
		}
		
		const topic = topicInfo.data[0];
		if (topic.creator !== userId) {
			return {
				code: -1,
				message: '只有创建者可以修改专题',
				data: null
			};
		}
		
		// 构建更新数据
		const updateData = {
			updateTime: Date.now()
		};
		
		if (title !== undefined) updateData.title = title;
		if (description !== undefined) updateData.description = description;
		if (cover_image !== undefined) updateData.cover_image = cover_image;
		if (allowOthersUpload !== undefined) updateData.allowOthersUpload = allowOthersUpload;
		if (isPublic !== undefined) updateData.isPublic = isPublic;
		
		// 更新数据
		await topicCollection.doc(topicId).update(updateData);
		
		return {
			code: 0,
			message: '更新专题成功',
			data: {
				id: topicId,
				...updateData
			}
		};
	} catch (error) {
		console.error('更新专题失败:', error);
		return {
			code: -1,
			message: '更新专题失败: ' + error.message,
			data: null
		};
	}
}

/**
 * 删除专题
 */
async function deleteTopic(event) {
	const { userId, topicId } = event;
	
	if (!topicId) {
		return {
			code: -1,
			message: '专题ID不能为空',
			data: null
		};
	}
	
	try {
		// 检查是否是专题创建者
		const topicInfo = await topicCollection.doc(topicId).get();
		if (!topicInfo.data || topicInfo.data.length === 0) {
			return {
				code: -1,
				message: '专题不存在',
				data: null
			};
		}
		
		const topic = topicInfo.data[0];
		if (topic.creator !== userId) {
			return {
				code: -1,
				message: '只有创建者可以删除专题',
				data: null
			};
		}
		
		// 解除专题与视频的关联 - 统一使用learning_videos集合
		const videoCollection = db.collection('learning_videos'); // 明确定义集合引用
		await videoCollection.where({
			topic_id: topicId, // 统一使用topic_id字段
			video_type: 'topic' // 确保只处理专题视频
		}).update({
			topic_id: '', // 清空专题ID
			topic_title: '', // 清空专题标题  
			video_type: 'channel' // 转换为分区视频
		});
		
		// 删除专题
		await topicCollection.doc(topicId).remove();
		
		return {
			code: 0,
			message: '删除专题成功',
			data: null
		};
	} catch (error) {
		console.error('删除专题失败:', error);
		return {
			code: -1,
			message: '删除专题失败: ' + error.message,
			data: null
		};
	}
}

/**
 * 获取专题的视频列表
 */
async function getTopicVideos(event) {
	const { topicId, page = 1, pageSize = 10 } = event;
	
	console.log('[getTopicVideos] 接收到的参数:', { topicId, page, pageSize });
	
	if (!topicId) {
		return {
			code: -1,
			message: '专题ID不能为空',
			data: null
		};
	}
	
	try {
		// 检查专题是否存在
		const topicInfo = await topicCollection.doc(topicId).get();
		if (!topicInfo.data || topicInfo.data.length === 0) {
			console.log('[getTopicVideos] 专题不存在:', topicId);
			return {
				code: -1,
				message: '专题不存在',
				data: null
			};
		}
		
		console.log('[getTopicVideos] 找到专题:', topicInfo.data[0].title);
		
		// 获取专题下的视频列表 - 统一使用learning_videos集合
		const skip = (page - 1) * pageSize;
		const videoCollection = db.collection('learning_videos'); // 统一使用learning_videos集合
		
		const whereCondition = {
			topic_id: topicId, // 专题ID关联
			video_type: 'topic', // 明确标记为专题视频
			status: 'published' // 只获取已发布的视频
		};
		
		console.log('[getTopicVideos] 视频查询条件:', JSON.stringify(whereCondition));
		
		const list = await videoCollection
			.where(whereCondition)
			.orderBy('create_date', 'desc') // 统一使用create_date字段
			.skip(skip)
			.limit(pageSize)
			.get();
		
		console.log('[getTopicVideos] 查询到视频数量:', list.data.length);
		
		// 获取总数
		const countResult = await videoCollection.where(whereCondition).count();
		
		return {
			code: 0,
			message: '获取专题视频列表成功',
			data: list.data,
			total: countResult.total
		};
	} catch (error) {
		console.error('获取专题视频列表失败:', error);
		return {
			code: -1,
			message: '获取专题视频列表失败: ' + error.message,
			data: null
		};
	}
} 